﻿/********************************************************************************
     File:																
            BusinessFacade.cs                         
     Description:
            业务逻辑类
     Author:									
            DDBuildTools
            http://FrameWork.supesoft.com
     Finish DateTime:
			2013/4/1 12:21:45
     History:
*********************************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using Model.Components;
using Model.Data;

using FrameWork.Components;

namespace Model
{
    /// <summary>
    /// 业务逻辑类
    /// </summary>
    public partial class BusinessFacadeModel
    {

        #region "T_TJ(T_TJ) - Method"

        /// <summary>
        /// 新增/删除/修改 T_TJEntity (T_TJ)
        /// </summary>
        /// <param name="fam">T_TJEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 T_TJInsertUpdateDelete(T_TJEntity fam)
        {
            return DataProvider.Instance().T_TJInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据id返回 T_TJEntity实体类 单笔资料 (T_TJ)
        /// </summary>
        /// <param name="id">id 序号</param>
        /// <returns>返回 T_TJEntity实体类 id为0则无记录</returns>
        public static T_TJEntity T_TJDisp(Int32 id)
        {
            T_TJEntity fam = new T_TJEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "T_TJ", "id", id);
            int RecordCount = 0;
            List<T_TJEntity> lst = T_TJList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回T_TJEntity实体类的List对象 (T_TJ)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>T_TJEntity实体类的List对象(T_TJ)</returns>
        public static List<T_TJEntity> T_TJList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "T_TJ";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "id";
            }
            else if (qp.Orderfld != "id")
            {
                qp.Orderfld += ",id";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().T_TJList(qp, out RecordCount);
        }
        #endregion

        #region "T_TouSu(**办理) - Method"

        /// <summary>
        /// 新增/删除/修改 T_TouSuEntity (**办理)
        /// </summary>
        /// <param name="fam">T_TouSuEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 T_TouSuInsertUpdateDelete(T_TouSuEntity fam)
        {
            return DataProvider.Instance().T_TouSuInsertUpdateDelete(fam);
        }
        
        /// <summary>
        /// 根据ID返回 T_TouSuEntity实体类 单笔资料 (**办理)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 T_TouSuEntity实体类 ID为0则无记录</returns>
        public static T_TouSuEntity T_TouSuDisp(Int32 ID)
        {
            T_TouSuEntity fam = new T_TouSuEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}","T_TouSu","ID",ID);
            int RecordCount = 0;
            List<T_TouSuEntity> lst = T_TouSuList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回T_TouSuEntity实体类的List对象 (**办理)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>T_TouSuEntity实体类的List对象(**办理)</returns>
        public static List<T_TouSuEntity> T_TouSuList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "T_TouSu";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }
            
            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().T_TouSuList(qp, out RecordCount);
        }
        #endregion

        #region "T_Web(网上投诉) - Method"

        /// <summary>
        /// 新增/删除/修改 T_WebEntity (网上投诉)
        /// </summary>
        /// <param name="fam">T_WebEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 T_WebInsertUpdateDelete(T_WebEntity fam)
        {
            return DataProvider.Instance().T_WebInsertUpdateDelete(fam);
        }
        
        /// <summary>
        /// 根据ID返回 T_WebEntity实体类 单笔资料 (网上投诉)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 T_WebEntity实体类 ID为0则无记录</returns>
        public static T_WebEntity T_WebDisp(Int32 ID)
        {
            T_WebEntity fam = new T_WebEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}","T_Web","ID",ID);
            int RecordCount = 0;
            List<T_WebEntity> lst = T_WebList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回T_WebEntity实体类的List对象 (网上投诉)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>T_WebEntity实体类的List对象(网上投诉)</returns>
        public static List<T_WebEntity> T_WebList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "T_Web";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }
            
            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().T_WebList(qp, out RecordCount);
        }
        #endregion

        #region "LFSea(来访季报表) - Method"

        /// <summary>
        /// 新增/删除/修改 LFSeaEntity (来访季报表)
        /// </summary>
        /// <param name="fam">LFSeaEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 LFSeaInsertUpdateDelete(LFSeaEntity fam)
        {
            return DataProvider.Instance().LFSeaInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 LFSeaEntity实体类 单笔资料 (来访季报表)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 LFSeaEntity实体类 ID为0则无记录</returns>
        public static LFSeaEntity LFSeaDisp(Int32 ID)
        {
            LFSeaEntity fam = new LFSeaEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "LFSea", "ID", ID);
            int RecordCount = 0;
            List<LFSeaEntity> lst = LFSeaList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回LFSeaEntity实体类的List对象 (来访季报表)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>LFSeaEntity实体类的List对象(来访季报表)</returns>
        public static List<LFSeaEntity> LFSeaList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "LFSea";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().LFSeaList(qp, out RecordCount);
        }
        #endregion

        #region "LFYear(来访季报表) - Method"

        /// <summary>
        /// 新增/删除/修改 LFYearEntity (来访季报表)
        /// </summary>
        /// <param name="fam">LFYearEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 LFYearInsertUpdateDelete(LFYearEntity fam)
        {
            return DataProvider.Instance().LFYearInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 LFYearEntity实体类 单笔资料 (来访季报表)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 LFYearEntity实体类 ID为0则无记录</returns>
        public static LFYearEntity LFYearDisp(Int32 ID)
        {
            LFYearEntity fam = new LFYearEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "LFYear", "ID", ID);
            int RecordCount = 0;
            List<LFYearEntity> lst = LFYearList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回LFYearEntity实体类的List对象 (来访季报表)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>LFYearEntity实体类的List对象(来访季报表)</returns>
        public static List<LFYearEntity> LFYearList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "LFYear";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().LFYearList(qp, out RecordCount);
        }
        #endregion

        #region "LXSea(信访工作来信季报表) - Method"

        /// <summary>
        /// 新增/删除/修改 LXSeaEntity (信访工作来信季报表)
        /// </summary>
        /// <param name="fam">LXSeaEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 LXSeaInsertUpdateDelete(LXSeaEntity fam)
        {
            return DataProvider.Instance().LXSeaInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 LXSeaEntity实体类 单笔资料 (信访工作来信季报表)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 LXSeaEntity实体类 ID为0则无记录</returns>
        public static LXSeaEntity LXSeaDisp(Int32 ID)
        {
            LXSeaEntity fam = new LXSeaEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "LXSea", "ID", ID);
            int RecordCount = 0;
            List<LXSeaEntity> lst = LXSeaList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回LXSeaEntity实体类的List对象 (信访工作来信季报表)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>LXSeaEntity实体类的List对象(信访工作来信季报表)</returns>
        public static List<LXSeaEntity> LXSeaList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "LXSea";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().LXSeaList(qp, out RecordCount);
        }
        #endregion

        #region "LXYear(信访工作来信季报表) - Method"

        /// <summary>
        /// 新增/删除/修改 LXYearEntity (信访工作来信季报表)
        /// </summary>
        /// <param name="fam">LXYearEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 LXYearInsertUpdateDelete(LXYearEntity fam)
        {
            return DataProvider.Instance().LXYearInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 LXYearEntity实体类 单笔资料 (信访工作来信季报表)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 LXYearEntity实体类 ID为0则无记录</returns>
        public static LXYearEntity LXYearDisp(Int32 ID)
        {
            LXYearEntity fam = new LXYearEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "LXYear", "ID", ID);
            int RecordCount = 0;
            List<LXYearEntity> lst = LXYearList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回LXYearEntity实体类的List对象 (信访工作来信季报表)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>LXYearEntity实体类的List对象(信访工作来信季报表)</returns>
        public static List<LXYearEntity> LXYearList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "LXYear";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().LXYearList(qp, out RecordCount);
        }
        #endregion

        #region "Mao(矛盾纠纷统计) - Method"

        /// <summary>
        /// 新增/删除/修改 MaoEntity (矛盾纠纷统计)
        /// </summary>
        /// <param name="fam">MaoEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 MaoInsertUpdateDelete(MaoEntity fam)
        {
            return DataProvider.Instance().MaoInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 MaoEntity实体类 单笔资料 (矛盾纠纷统计)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 MaoEntity实体类 ID为0则无记录</returns>
        public static MaoEntity MaoDisp(Int32 ID)
        {
            MaoEntity fam = new MaoEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "Mao", "ID", ID);
            int RecordCount = 0;
            List<MaoEntity> lst = MaoList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回MaoEntity实体类的List对象 (矛盾纠纷统计)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>MaoEntity实体类的List对象(矛盾纠纷统计)</returns>
        public static List<MaoEntity> MaoList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "Mao";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().MaoList(qp, out RecordCount);
        }
        #endregion

        #region "TA(提案办理情况 ) - Method"

        /// <summary>
        /// 新增/删除/修改 TAEntity (提案办理情况 )
        /// </summary>
        /// <param name="fam">TAEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 TAInsertUpdateDelete(TAEntity fam)
        {
            return DataProvider.Instance().TAInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 TAEntity实体类 单笔资料 (提案办理情况 )
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 TAEntity实体类 ID为0则无记录</returns>
        public static TAEntity TADisp(Int32 ID)
        {
            TAEntity fam = new TAEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "TA", "ID", ID);
            int RecordCount = 0;
            List<TAEntity> lst = TAList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回TAEntity实体类的List对象 (提案办理情况 )
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>TAEntity实体类的List对象(提案办理情况 )</returns>
        public static List<TAEntity> TAList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "TA";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().TAList(qp, out RecordCount);
        }
        #endregion

        #region "XF(环境信访数据统计) - Method"

        /// <summary>
        /// 新增/删除/修改 XFEntity (环境信访数据统计)
        /// </summary>
        /// <param name="fam">XFEntity实体类</param>
        /// <returns>-1:存储过程执行失败,-2:存在相同的主键,Insert:返回插入自动ID,Update:返回更新记录数,Delete:返回删除记录数</returns>
        public static Int32 XFInsertUpdateDelete(XFEntity fam)
        {
            return DataProvider.Instance().XFInsertUpdateDelete(fam);
        }

        /// <summary>
        /// 根据ID返回 XFEntity实体类 单笔资料 (环境信访数据统计)
        /// </summary>
        /// <param name="ID">ID ID</param>
        /// <returns>返回 XFEntity实体类 ID为0则无记录</returns>
        public static XFEntity XFDisp(Int32 ID)
        {
            XFEntity fam = new XFEntity();
            QueryParam qp = new QueryParam();
            qp.PageIndex = 1;
            qp.PageSize = 1;
            qp.Where = string.Format(" Where {0}.{1} = {2}", "XF", "ID", ID);
            int RecordCount = 0;
            List<XFEntity> lst = XFList(qp, out RecordCount);
            if (RecordCount > 0)
            {
                fam = lst[0];
            }
            return fam;
        }

        /// <summary>
        /// 返回XFEntity实体类的List对象 (环境信访数据统计)
        /// </summary>
        /// <param name="qp">查询类(非安全函数,传入参数请进行Sql字符串过滤)</param>
        /// <param name="RecordCount">返回记录总数</param>
        /// <returns>XFEntity实体类的List对象(环境信访数据统计)</returns>
        public static List<XFEntity> XFList(QueryParam qp, out int RecordCount)
        {
            qp.TableName = "XF";
            if (qp.Orderfld == null)
            {
                qp.Orderfld = "ID";
            }
            else if (qp.Orderfld != "ID")
            {
                qp.Orderfld += ",ID";
            }

            if (qp.ReturnFields == null)
            {
                qp.ReturnFields = "*";
            }
            else
            {
                qp.ReturnFields += ",";
                qp.ReturnFields += qp.Orderfld;
            }
            return DataProvider.Instance().XFList(qp, out RecordCount);
        }
        #endregion



        #region "获取表中字段值"
        /// <summary>
        /// 获取表中字段值(非安全函数,传入参数请进行Sql字符串过滤)
        /// </summary>
        /// <param name="table_name">表名</param>
        /// <param name="table_fileds">字段</param>
        /// <param name="where_fileds">查询条件字段</param>
        /// <param name="where_value">查询值</param>
        /// <returns></returns>
        public static string get_table_fileds(string table_name, string table_fileds, string where_fileds, string where_value)
        {
            return DataProvider.Instance().get_table_fileds(table_name, table_fileds, where_fileds, where_value);
        }

        public static string get_table_fileds2(string table_name, string table_fileds, string where_fileds, string where_value, string where_fields2, string wherefieldvalue2, string where_fields3, string where_value3, string where_fields4, string where_value4)
        {
            return DataProvider.Instance().get_table_fileds2(table_name, table_fileds, where_fileds, where_value, where_fields2, wherefieldvalue2, where_fields3, where_value3, where_fields4, where_value4);
        }

        public static string get_table_fileds3(string table_name, string table_fileds, string where_fileds, string where_value, string where_fields2, string wherefieldvalue2, string where_fields3, string where_value3, string where_fields4, string where_value4)
        {
            return DataProvider.Instance().get_table_fileds3(table_name, table_fileds, where_fileds, where_value, where_fields2, wherefieldvalue2, where_fields3, where_value3, where_fields4, where_value4);
        }
        #endregion

        #region "列新表中字段值"
        /// <summary>
        /// 更新表中字段值(非安全函数,传入参数请进行Sql字符串过滤)
        /// </summary>
        /// <param name="Table">表名</param>
        /// <param name="Table_FiledsValue">需要更新值(不用带Set)</param>
        /// <param name="Wheres">更新条件(不用带Where)</param>
        /// <returns></returns>
        public static int Update_Table_Fileds(string Table, string Table_FiledsValue, string Wheres)
        {
            return DataProvider.Instance().Update_Table_Fileds(Table, Table_FiledsValue, Wheres);
        }

        #endregion
    }
}
